﻿#include<iostream>
#include<string>
#include<vector>

//#define MAX_SIZE 100
//
using namespace std;
//
//enum sex {
//	Man,
//	Woman,
//	Undefined
//};
//
//class Person
//{
//public:
//
//	//默认构造
//	Person(const char* _str = "张三")
//		:_name(_str)
//		,_age(0)
//		,_sex(Undefined)
//	{
//		cout << "There is Person()!" << endl;
//	}
//
//	//构造
//	Person(const char* name, int age, sex sex1)
//		:_name(name)
//		,_age(age)
//		,_sex(sex1)
//	{
//		cout << "There is Person()1!!" << endl;
//	}
//
//	//析构
//	~Person()
//	{
//		//这里不用手动析构_name,string类自动调用析构函数
//		/*_name = nullptr;*/
//		_age = 0;
//		_sex = Undefined;
//
//		cout << "There is ~Person()!" << endl;
//	}
//
//	//拷贝构造
//	Person(Person& _preson)
//	{
//		this->_age = _preson._age;
//		this->_sex = _preson._sex;
//		this->_name = _preson._name;
//	}
//
//	void Print()
//	{
//		cout << this->_age << endl;
//		cout << this->_name << endl;
//		cout << this->_sex << endl;
//	}
//
//
//protected:
//	string _name;
//	size_t _age;
//	sex _sex;
//};
//
//class Student : public Person
//{
//public:
//	//在派生类的构造函数中可以同时初始化基类的成员变量
//	Student(const char* _str1, const char* _str2)
//		:_id(_str1)
//		,_pofession(_str2)
//	{
//		cout << "There is Student()!" << endl;
//	}
//
//	Student(const char* name, int age, sex sex1, const char* _str1, const char* _str2)
//		:Person(name ,age, sex1)
//		,_id(_str1)
//		,_pofession(_str2)
//	{
//		cout << "There is Student()1!!" << endl;
//	}
//
//	~Student()
//	{
//		//这里不用手动析构_id和_pofession,string类自动调用析构函数
//		//_id = nullptr;
//		//_pofession = nullptr;
//
//		cout << "There is ~Student()!" << endl;
//	}
//
//	Student(Student& _student)
//	{
//		this->_id = _student._id;
//		this->_pofession = _student._pofession;
//	}
//
//	void Print()
//	{
//		cout << this->_name << endl;
//		cout << this->_age << endl;
//		cout << this->_sex << endl;
//		cout << this->_id << endl;
//		cout << this->_pofession << endl;
//	}
//private:
//	string _id;
//	string _pofession;
//};
//
//
//void Test1()
//{
//	Student my("202223415", "计算机科学与技术");
//	my.Print();
//	//继承规则：按权限最小的执行
//}
//
////继承类模板
////通过继承库函数中的vector类自主实现Stack
//template <class T>
//class Stack : public std::vector<T>
//{
//public:
//	//构造，拷贝构造，析构......走vector这套
//	void push(const T& value)
//	{
//		this->push_back(value);
//	}
//
//	void pop()
//	{
//		this->pop_back();
//	}
//
//	bool empty()
//	{
//		return this->empty();
//	}
//
//	T& top()
//	{
//		return this->back();
//	}
//};
//
//void Test2()
//{
//	Stack<int> mystack;
//
//	for (int i = 0; i < MAX_SIZE; i++)
//	{
//		mystack.push(i);
//	}
//
//	for (int i = 0; i < MAX_SIZE; i++)
//	{
//		cout<<mystack.top()<<endl;
//		mystack.pop();
//	}
//}
//
////基类和派生类之间的转化：切片
////  派生类对象可以传给基类的指针或者基类的引用
//
//void Test3()
//{
//	Student student1("王五子",30,Man,"33556687", "软件工程");
//
//	Person& person2 = student1;
//	Person* person3 = &student1;
//
//	person2.Print();
//	person3->Print();
//}
//
////继承中的作用域
////	1. 在继承体系中基类和派⽣类都有独⽴的作⽤域。
////	2. 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。
////    （在派⽣类成员函数中，可以使⽤ 基类::基类成员 显⽰访问）
////  3.函数只要函数名相同就构成隐藏
//
//class Base
//{
//protected:
//	int a = 0;
//	int num = 888;
//};
//
//class Derived : public Base
//{
//public:
//	void Print()
//	{
//		cout << "a : " << a << endl;
//		cout << "b : " << b << endl; 
//		cout << "Base::num : " << Base::num << endl;
//		cout << "Derived::num : " << Derived::num << endl;
//	}
//private:
//	int b = 10;
//	int num = 999;
//};
//
//void Test4()
//{
//	Derived tmp;
//	tmp.Print();
//}
//
////基类的默认成员函数和派生类默认成员函数之间的关系
//class Person1
//{
//public:
//	Person1(const char* _str)
//		:_names(_str)
//	{
//		cout << "There is Person1()!" << endl;
//	}
//
//	~Person1()
//	{
//		//string 类自动调用析构函数
//		cout << "There is ~Person1()" << endl;
//	}
//
//	Person1(Person1& _person)
//	{
//		this->_names = _person._names;
//		cout << "There is copy_Preson()!" << endl;
//	}
//
//	Person1& operator=(Person1& _person1)
//	{
//		this->_names = _person1._names;
//
//		cout << "There is Person1& operator=(Person1& _person1)!" << endl;
//		return *this;
//	}
//protected:
//	string _names;
//};
//
//class Student1 : public Person1
//{
//public:
//	//基类没有默认的构造函数，需要在初始化列表显示调用
//	Student1(const char* _str1, const char* _str2, int _id)
//		:Person1(_str1)
//		,pofession(_str2)
//		,id(_id)
//	{
//		cout << "There is Student1()!" << endl;
//	}
//
//	~Student1()
//	{
//		id = 0;
//		//string 类自动析构
//
//		cout << "There is ~Student1()" << endl;
//	}
//
//	//基类没有默认构造函数，派生类的拷贝构造也要显示调用基类的构造函数
//	Student1(Student1& tmp)
//		//派生类对象传给基类的引用
//		:Person1(tmp)
//	{
//		this->id = tmp.id;
//		this->pofession = tmp.pofession;
//
//		cout << "There is copy_Student1()!" << endl;
//	}
//
//	Student1& operator=(Student1& _student1)
//	{
//		this->id = _student1.id;
//		this->pofession = _student1.pofession;
//		this->_names = _student1._names;
//
//		cout << "There is Student1& operator=(Student1& _student1)!" << endl;
//
//		return *this;
//	}
//private:
//	string pofession;
//	int id;
//};
//
//void Test5()
//{
//	Student1 _stu("王五","计算机科学与技术",1123123);
//
//	cout << endl << endl;
//
//	//Student1 _stu1 = _stu;
//
//	Student1 _stu1(_stu);
//
//	//_stu1 = _stu;
//
//	cout << endl << endl;
//
//	Student1 _stu2("李四","物联网",55882230);
//
//	_stu2 = _stu;
//
//}

//继承与静态成员:
//基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个派⽣类，都
//只有⼀个static成员实例。

/*class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};

void Test6()
{
	Person p;
	Student s;
	 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
	 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
	cout << &p._name << endl;
	cout << &s._name << endl;
	 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
	 说明派⽣类和基类共⽤同⼀份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;
	 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
	cout << Person::_count << endl;

	cout << Student::_count << endl;
}*/

//多继承和菱形继承问题
//class Person
//{
//public:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//
//void Test7()
//{
//	// 编译报错：error C2385: 对“_name”的访问不明确
//	Assistant a;
//	//a._name = "peter";
//	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//}

int main()
{
	//Test1();
	//Test2();
	//Test3();
	//Test4();
	//Test5();
	//Test6();
	//Test7();
	return 0;
}